// Copyright 2006 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @fileoverview Bootstrap for the Google JS Library (Closure).
 *
 * In uncompiled mode base.js will attempt to load Closure's deps file, unless
 * the global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects
 * to include their own deps file(s) from different locations.
 *
 * Avoid including base.js more than once. This is strictly discouraged and not
 * supported. goog.require(...) won't work properly in that case.
 *
 * @provideGoog
 */

/**
 * @define {boolean} Overridden to true by the compiler.
 */
var COMPILED = false;
// 更改 解决 小程序 undefined 问题
var _window = {}
var navigator = {
	userAgent: "mimc-uniapp/1.0",
	appName: "xiaomi",
	appVersion: "1.0"
}
_window.navigator = navigator

/**
 * Base namespace for the Closure library.  Checks to see goog is already
 * defined in the current scope before assigning to prevent clobbering if
 * base.js is loaded more than once.
 *
 * @const
 */
var goog = goog || {};

/**
 * Reference to the global context.  In most cases this will be 'window'.
 */
goog.global = this;


// 更改
function InvalidCharacterError(message) {
	this.message = message;
}
InvalidCharacterError.prototype = new Error;
InvalidCharacterError.prototype.name = 'InvalidCharacterError';

// 更改
if(goog.global == undefined) {
	goog.global = {}
	var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
	if(goog.global.atob == undefined) {
		goog.global.atob = function(input) {
			var str = String(input).replace(/[=]+$/, ''); // #31: ExtendScript bad parse of /=
			if(str.length % 4 == 1) {
				throw new InvalidCharacterError("'atob' failed: The string to be decoded is not correctly encoded.");
			}
			for(
				// initialize result and counters
				var bc = 0, bs, buffer, idx = 0, output = '';
				// get next character
				buffer = str.charAt(idx++);
				// character found in table? initialize bit storage and add its ascii value;
				~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,
					// and if not first of each 4 characters,
					// convert the first 8 bits to one ascii character
					bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0
			) {
				// try to find character in table (0-63, not found => -1)
				buffer = chars.indexOf(buffer);
			}
			return output;
		}

	}
	
	if(goog.global.btoa == undefined) {
		goog.global.btoa = function(input){
			var str = String(input);
			for(
				// initialize result and counter
				var block, charCode, idx = 0, map = chars, output = '';
				// if the next str index does not exist:
				//   change the mapping table to "="
				//   check if d has no fractional digits
				str.charAt(idx | 0) || (map = '=', idx % 1);
				// "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
				output += map.charAt(63 & block >> 8 - idx % 1 * 8)
			) {
				charCode = str.charCodeAt(idx += 3 / 4);
				if(charCode > 0xFF) {
					throw new InvalidCharacterError("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
				}
				block = block << 8 | charCode;
			}
			return output;
		}

	}

}
// end 更改

/**
 * A hook for overriding the define values in uncompiled mode.
 *
 * In uncompiled mode, {@code CLOSURE_UNCOMPILED_DEFINES} may be defined before
 * loading base.js.  If a key is defined in {@code CLOSURE_UNCOMPILED_DEFINES},
 * {@code goog.define} will use the value instead of the default value.  This
 * allows flags to be overwritten without compilation (this is normally
 * accomplished with the compiler's "define" flag).
 *
 * Example:
 * <pre>
 *   var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};
 * </pre>
 *
 * @type {Object<string, (string|number|boolean)>|undefined}
 */
goog.global.CLOSURE_UNCOMPILED_DEFINES;

/**
 * A hook for overriding the define values in uncompiled or compiled mode,
 * like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code.  In
 * uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.
 *
 * Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or
 * string literals or the compiler will emit an error.
 *
 * While any @define value may be set, only those set with goog.define will be
 * effective for uncompiled code.
 *
 * Example:
 * <pre>
 *   var CLOSURE_DEFINES = {'goog.DEBUG': false} ;
 * </pre>
 *
 * @type {Object<string, (string|number|boolean)>|undefined}
 */
goog.global.CLOSURE_DEFINES;

/**
 * Returns true if the specified value is not undefined.
 *
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is defined.
 */
goog.isDef = function(val) {
	// void 0 always evaluates to undefined and hence we do not need to depend on
	// the definition of the global variable named 'undefined'.
	return val !== void 0;
};

/**
 * Returns true if the specified value is a string.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a string.
 */
goog.isString = function(val) {
	return typeof val == 'string';
};

/**
 * Returns true if the specified value is a boolean.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is boolean.
 */
goog.isBoolean = function(val) {
	return typeof val == 'boolean';
};

/**
 * Returns true if the specified value is a number.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a number.
 */
goog.isNumber = function(val) {
	return typeof val == 'number';
};

/**
 * Builds an object structure for the provided namespace path, ensuring that
 * names that already exist are not overwritten. For example:
 * "a.b.c" -> a = {};a.b={};a.b.c={};
 * Used by goog.provide and goog.exportSymbol.
 * @param {string} name name of the object that this file defines.
 * @param {*=} opt_object the object to expose at the end of the path.
 * @param {Object=} opt_objectToExportTo The object to add the path to; default
 *     is `goog.global`.
 * @private
 */
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
	var parts = name.split('.');
	var cur = opt_objectToExportTo || goog.global;

	// Internet Explorer exhibits strange behavior when throwing errors from
	// methods externed in this manner.  See the testExportSymbolExceptions in
	// base_test.html for an example.
	if(!(parts[0] in cur) && cur.execScript) {
		cur.execScript('var ' + parts[0]);
	}

	for(var part; parts.length && (part = parts.shift());) {
		if(!parts.length && goog.isDef(opt_object)) {
			// last part and we have an object; use it
			cur[part] = opt_object;
		} else if(cur[part] && cur[part] !== Object.prototype[part]) {
			cur = cur[part];
		} else {
			cur = cur[part] = {};
		}
	}
};

/**
 * Defines a named value. In uncompiled mode, the value is retrieved from
 * CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and
 * has the property specified, and otherwise used the defined defaultValue.
 * When compiled the default can be overridden using the compiler
 * options or the value set in the CLOSURE_DEFINES object.
 *
 * @param {string} name The distinguished name to provide.
 * @param {string|number|boolean} defaultValue
 */
goog.define = function(name, defaultValue) {
	var value = defaultValue;
	if(!COMPILED) {
		if(goog.global.CLOSURE_UNCOMPILED_DEFINES &&
			// Anti DOM-clobbering runtime check (b/37736576).
			/** @type {?} */
			(goog.global.CLOSURE_UNCOMPILED_DEFINES).nodeType ===
			undefined &&
			Object.prototype.hasOwnProperty.call(
				goog.global.CLOSURE_UNCOMPILED_DEFINES, name)) {
			value = goog.global.CLOSURE_UNCOMPILED_DEFINES[name];
		} else if(
			goog.global.CLOSURE_DEFINES &&
			// Anti DOM-clobbering runtime check (b/37736576).
			/** @type {?} */
			(goog.global.CLOSURE_DEFINES).nodeType === undefined &&
			Object.prototype.hasOwnProperty.call(
				goog.global.CLOSURE_DEFINES, name)) {
			value = goog.global.CLOSURE_DEFINES[name];
		}
	}
	goog.exportPath_(name, value);
};

/**
 * @define {boolean} DEBUG is provided as a convenience so that debugging code
 * that should not be included in a production. It can be easily stripped
 * by specifying --define goog.DEBUG=false to the Closure Compiler aka
 * JSCompiler. For example, most toString() methods should be declared inside an
 * "if (goog.DEBUG)" conditional because they are generally used for debugging
 * purposes and it is difficult for the JSCompiler to statically determine
 * whether they are used.
 */
goog.define('goog.DEBUG', true);

/**
 * @define {string} LOCALE defines the locale being used for compilation. It is
 * used to select locale specific data to be compiled in js binary. BUILD rule
 * can specify this value by "--define goog.LOCALE=<locale_name>" as a compiler
 * option.
 *
 * Take into account that the locale code format is important. You should use
 * the canonical Unicode format with hyphen as a delimiter. Language must be
 * lowercase, Language Script - Capitalized, Region - UPPERCASE.
 * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.
 *
 * See more info about locale codes here:
 * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers
 *
 * For language codes you should use values defined by ISO 693-1. See it here
 * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from
 * this rule: the Hebrew language. For legacy reasons the old code (iw) should
 * be used instead of the new code (he).
 *
 */
goog.define('goog.LOCALE', 'en'); // default to en

/**
 * @define {boolean} Whether this code is running on trusted sites.
 *
 * On untrusted sites, several native functions can be defined or overridden by
 * external libraries like Prototype, Datejs, and JQuery and setting this flag
 * to false forces closure to use its own implementations when possible.
 *
 * If your JavaScript can be loaded by a third party site and you are wary about
 * relying on non-standard implementations, specify
 * "--define goog.TRUSTED_SITE=false" to the compiler.
 */
goog.define('goog.TRUSTED_SITE', true);

/**
 * @define {boolean} Whether a project is expected to be running in strict mode.
 *
 * This define can be used to trigger alternate implementations compatible with
 * running in EcmaScript Strict mode or warn about unavailable functionality.
 * @see https://goo.gl/PudQ4y
 *
 */
goog.define('goog.STRICT_MODE_COMPATIBLE', false);

/**
 * @define {boolean} Whether code that calls {@link goog.setTestOnly} should
 *     be disallowed in the compilation unit.
 */
goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);

/**
 * @define {boolean} Whether to use a Chrome app CSP-compliant method for
 *     loading scripts via goog.require. @see appendScriptSrcNode_.
 */
goog.define('goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING', false);

/**
 * Defines a namespace in Closure.
 *
 * A namespace may only be defined once in a codebase. It may be defined using
 * goog.provide() or goog.module().
 *
 * The presence of one or more goog.provide() calls in a file indicates
 * that the file defines the given objects/namespaces.
 * Provided symbols must not be null or undefined.
 *
 * In addition, goog.provide() creates the object stubs for a namespace
 * (for example, goog.provide("goog.foo.bar") will create the object
 * goog.foo.bar if it does not already exist).
 *
 * Build tools also scan for provide/require/module statements
 * to discern dependencies, build dependency files (see deps.js), etc.
 *
 * @see goog.require
 * @see goog.module
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part".
 */
goog.provide = function(name) {
	if(goog.isInModuleLoader_()) {
		throw new Error('goog.provide can not be used within a goog.module.');
	}
	if(!COMPILED) {
		// Ensure that the same namespace isn't provided twice.
		// A goog.module/goog.provide maps a goog.require to a specific file
		if(goog.isProvided_(name)) {
			throw new Error('Namespace "' + name + '" already declared.');
		}
	}

	goog.constructNamespace_(name);
};

/**
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part".
 * @param {Object=} opt_obj The object to embed in the namespace.
 * @private
 */
goog.constructNamespace_ = function(name, opt_obj) {
	if(!COMPILED) {
		delete goog.implicitNamespaces_[name];

		var namespace = name;
		while((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
			if(goog.getObjectByName(namespace)) {
				break;
			}
			goog.implicitNamespaces_[namespace] = true;
		}
	}

	goog.exportPath_(name, opt_obj);
};

/**
 * Module identifier validation regexp.
 * Note: This is a conservative check, it is very possible to be more lenient,
 *   the primary exclusion here is "/" and "\" and a leading ".", these
 *   restrictions are intended to leave the door open for using goog.require
 *   with relative file paths rather than module identifiers.
 * @private
 */
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;

/**
 * Defines a module in Closure.
 *
 * Marks that this file must be loaded as a module and claims the namespace.
 *
 * A namespace may only be defined once in a codebase. It may be defined using
 * goog.provide() or goog.module().
 *
 * goog.module() has three requirements:
 * - goog.module may not be used in the same file as goog.provide.
 * - goog.module must be the first statement in the file.
 * - only one goog.module is allowed per file.
 *
 * When a goog.module annotated file is loaded, it is enclosed in
 * a strict function closure. This means that:
 * - any variables declared in a goog.module file are private to the file
 * (not global), though the compiler is expected to inline the module.
 * - The code must obey all the rules of "strict" JavaScript.
 * - the file will be marked as "use strict"
 *
 * NOTE: unlike goog.provide, goog.module does not declare any symbols by
 * itself. If declared symbols are desired, use
 * goog.module.declareLegacyNamespace().
 *
 *
 * See the public goog.module proposal: http://goo.gl/Va1hin
 *
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part", is expected but not required.
 * @return {void}
 */
goog.module = function(name) {
	if(!goog.isString(name) || !name ||
		name.search(goog.VALID_MODULE_RE_) == -1) {
		throw new Error('Invalid module identifier');
	}
	if(!goog.isInModuleLoader_()) {
		throw new Error(
			'Module ' + name + ' has been loaded incorrectly. Note, ' +
			'modules cannot be loaded as normal scripts. They require some kind of ' +
			'pre-processing step. You\'re likely trying to load a module via a ' +
			'script tag or as a part of a concatenated bundle without rewriting the ' +
			'module. For more info see: ' +
			'https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.');
	}
	if(goog.moduleLoaderState_.moduleName) {
		throw new Error('goog.module may only be called once per module.');
	}

	// Store the module name for the loader.
	goog.moduleLoaderState_.moduleName = name;
	if(!COMPILED) {
		// Ensure that the same namespace isn't provided twice.
		// A goog.module/goog.provide maps a goog.require to a specific file
		if(goog.isProvided_(name)) {
			throw new Error('Namespace "' + name + '" already declared.');
		}
		delete goog.implicitNamespaces_[name];
	}
};

/**
 * @param {string} name The module identifier.
 * @return {?} The module exports for an already loaded module or null.
 *
 * Note: This is not an alternative to goog.require, it does not
 * indicate a hard dependency, instead it is used to indicate
 * an optional dependency or to access the exports of a module
 * that has already been loaded.
 * @suppress {missingProvide}
 */
goog.module.get = function(name) {
	return goog.module.getInternal_(name);
};

/**
 * @param {string} name The module identifier.
 * @return {?} The module exports for an already loaded module or null.
 * @private
 */
goog.module.getInternal_ = function(name) {
	if(!COMPILED) {
		if(name in goog.loadedModules_) {
			return goog.loadedModules_[name];
		} else if(!goog.implicitNamespaces_[name]) {
			var ns = goog.getObjectByName(name);
			return ns != null ? ns : null;
		}
	}
	return null;
};

/**
 * @private {?{moduleName: (string|undefined), declareLegacyNamespace:boolean}}
 */
goog.moduleLoaderState_ = null;

/**
 * @private
 * @return {boolean} Whether a goog.module is currently being initialized.
 */
goog.isInModuleLoader_ = function() {
	return goog.moduleLoaderState_ != null;
};

/**
 * Provide the module's exports as a globally accessible object under the
 * module's declared name.  This is intended to ease migration to goog.module
 * for files that have existing usages.
 * @suppress {missingProvide}
 */
goog.module.declareLegacyNamespace = function() {
	if(!COMPILED && !goog.isInModuleLoader_()) {
		throw new Error(
			'goog.module.declareLegacyNamespace must be called from ' +
			'within a goog.module');
	}
	if(!COMPILED && !goog.moduleLoaderState_.moduleName) {
		throw new Error(
			'goog.module must be called prior to ' +
			'goog.module.declareLegacyNamespace.');
	}
	goog.moduleLoaderState_.declareLegacyNamespace = true;
};

/**
 * Marks that the current file should only be used for testing, and never for
 * live code in production.
 *
 * In the case of unit tests, the message may optionally be an exact namespace
 * for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra
 * provide (if not explicitly defined in the code).
 *
 * @param {string=} opt_message Optional message to add to the error that's
 *     raised when used in production code.
 */
goog.setTestOnly = function(opt_message) {
	if(goog.DISALLOW_TEST_ONLY_CODE) {
		opt_message = opt_message || '';
		throw new Error(
			'Importing test-only code into non-debug environment' +
			(opt_message ? ': ' + opt_message : '.'));
	}
};

/**
 * Forward declares a symbol. This is an indication to the compiler that the
 * symbol may be used in the source yet is not required and may not be provided
 * in compilation.
 *
 * The most common usage of forward declaration is code that takes a type as a
 * function parameter but does not need to require it. By forward declaring
 * instead of requiring, no hard dependency is made, and (if not required
 * elsewhere) the namespace may never be required and thus, not be pulled
 * into the JavaScript binary. If it is required elsewhere, it will be type
 * checked as normal.
 *
 * Before using goog.forwardDeclare, please read the documentation at
 * https://github.com/google/closure-compiler/wiki/Bad-Type-Annotation to
 * understand the options and tradeoffs when working with forward declarations.
 *
 * @param {string} name The namespace to forward declare in the form of
 *     "goog.package.part".
 */
goog.forwardDeclare = function(name) {};

/**
 * Forward declare type information. Used to assign types to goog.global
 * referenced object that would otherwise result in unknown type references
 * and thus block property disambiguation.
 */
goog.forwardDeclare('Document');
goog.forwardDeclare('HTMLScriptElement');
goog.forwardDeclare('XMLHttpRequest');

if(!COMPILED) {
	/**
	 * Check if the given name has been goog.provided. This will return false for
	 * names that are available only as implicit namespaces.
	 * @param {string} name name of the object to look for.
	 * @return {boolean} Whether the name has been provided.
	 * @private
	 */
	goog.isProvided_ = function(name) {
		return(name in goog.loadedModules_) ||
			(!goog.implicitNamespaces_[name] &&
				goog.isDefAndNotNull(goog.getObjectByName(name)));
	};

	/**
	 * Namespaces implicitly defined by goog.provide. For example,
	 * goog.provide('goog.events.Event') implicitly declares that 'goog' and
	 * 'goog.events' must be namespaces.
	 *
	 * @type {!Object<string, (boolean|undefined)>}
	 * @private
	 */
	goog.implicitNamespaces_ = {
		'goog.module': true
	};

	// NOTE: We add goog.module as an implicit namespace as goog.module is defined
	// here and because the existing module package has not been moved yet out of
	// the goog.module namespace. This satisifies both the debug loader and
	// ahead-of-time dependency management.
}

/**
 * Returns an object based on its fully qualified external name.  The object
 * is not found if null or undefined.  If you are using a compilation pass that
 * renames property names beware that using this function will not find renamed
 * properties.
 *
 * @param {string} name The fully qualified name.
 * @param {Object=} opt_obj The object within which to look; default is
 *     |goog.global|.
 * @return {?} The value (object or primitive) or, if not found, null.
 */
goog.getObjectByName = function(name, opt_obj) {
	var parts = name.split('.');
	var cur = opt_obj || goog.global;
	for(var i = 0; i < parts.length; i++) {
		cur = cur[parts[i]];
		if(!goog.isDefAndNotNull(cur)) {
			return null;
		}
	}
	return cur;
};

/**
 * Globalizes a whole namespace, such as goog or goog.lang.
 *
 * @param {!Object} obj The namespace to globalize.
 * @param {Object=} opt_global The object to add the properties to.
 * @deprecated Properties may be explicitly exported to the global scope, but
 *     this should no longer be done in bulk.
 */
goog.globalize = function(obj, opt_global) {
	var global = opt_global || goog.global;
	for(var x in obj) {
		global[x] = obj[x];
	}
};

/**
 * Adds a dependency from a file to the files it requires.
 * @param {string} relPath The path to the js file.
 * @param {!Array<string>} provides An array of strings with
 *     the names of the objects this file provides.
 * @param {!Array<string>} requires An array of strings with
 *     the names of the objects this file requires.
 * @param {boolean|!Object<string>=} opt_loadFlags Parameters indicating
 *     how the file must be loaded.  The boolean 'true' is equivalent
 *     to {'module': 'goog'} for backwards-compatibility.  Valid properties
 *     and values include {'module': 'goog'} and {'lang': 'es6'}.
 */
goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
	if(goog.DEPENDENCIES_ENABLED) {
		var loader = goog.getLoader_();
		if(loader) {
			loader.addDependency(relPath, provides, requires, opt_loadFlags);
		}
	}
};

// NOTE(nnaze): The debug DOM loader was included in base.js as an original way
// to do "debug-mode" development.  The dependency system can sometimes be
// confusing, as can the debug DOM loader's asynchronous nature.
//
// With the DOM loader, a call to goog.require() is not blocking -- the script
// will not load until some point after the current script.  If a namespace is
// needed at runtime, it needs to be defined in a previous script, or loaded via
// require() with its registered dependencies.
//
// User-defined namespaces may need their own deps file. For a reference on
// creating a deps file, see:
// Externally: https://developers.google.com/closure/library/docs/depswriter
//
// Because of legacy clients, the DOM loader can't be easily removed from
// base.js.  Work was done to make it disableable or replaceable for
// different environments (DOM-less JavaScript interpreters like Rhino or V8,
// for example). See bootstrap/ for more information.

/**
 * @define {boolean} Whether to enable the debug loader.
 *
 * If enabled, a call to goog.require() will attempt to load the namespace by
 * appending a script tag to the DOM (if the namespace has been registered).
 *
 * If disabled, goog.require() will simply assert that the namespace has been
 * provided (and depend on the fact that some outside tool correctly ordered
 * the script).
 */
goog.define('goog.ENABLE_DEBUG_LOADER', true);

/**
 * @param {string} msg
 * @private
 */
goog.logToConsole_ = function(msg) {
	if(goog.global.console) {
		goog.global.console['error'](msg);
	}
};

/**
 * Implements a system for the dynamic resolution of dependencies that works in
 * parallel with the BUILD system. Note that all calls to goog.require will be
 * stripped by the compiler.
 * @see goog.provide
 * @param {string} name Namespace to include (as was given in goog.provide()) in
 *     the form "goog.package.part".
 * @return {?} If called within a goog.module file, the associated namespace or
 *     module otherwise null.
 */
goog.require = function(name) {
	if(goog.ENABLE_DEBUG_LOADER && goog.debugLoader_) {
		goog.getLoader_().earlyProcessLoad(name);
	}

	// If the object already exists we do not need to do anything.
	if(!COMPILED) {
		if(goog.isProvided_(name)) {
			if(goog.isInModuleLoader_()) {
				return goog.module.getInternal_(name);
			}
		} else if(goog.ENABLE_DEBUG_LOADER) {
			var moduleLoaderState = goog.moduleLoaderState_;
			goog.moduleLoaderState_ = null;
			try {
				var loader = goog.getLoader_();
				if(loader) {
					loader.load(name);
				} else {
					goog.logToConsole_(
						'Could not load ' + name + ' because there is no debug loader.');
				}
			} finally {
				goog.moduleLoaderState_ = moduleLoaderState;
			}
		}

		return null;
	}
};

/**
 * Path for included scripts.
 * @type {string}
 */
goog.basePath = '';

/**
 * A hook for overriding the base path.
 * @type {string|undefined}
 */
goog.global.CLOSURE_BASE_PATH;

/**
 * Whether to attempt to load Closure's deps file. By default, when uncompiled,
 * deps files will attempt to be loaded.
 * @type {boolean|undefined}
 */
goog.global.CLOSURE_NO_DEPS;

/**
 * A function to import a single script. This is meant to be overridden when
 * Closure is being run in non-HTML contexts, such as web workers. It's defined
 * in the global scope so that it can be set before base.js is loaded, which
 * allows deps.js to be imported properly.
 *
 * The function is passed the script source, which is a relative URI. It should
 * return true if the script was imported, false otherwise.
 * @type {(function(string): boolean)|undefined}
 */
goog.global.CLOSURE_IMPORT_SCRIPT;

/**
 * Null function used for default values of callbacks, etc.
 * @return {void} Nothing.
 */
goog.nullFunction = function() {};

/**
 * When defining a class Foo with an abstract method bar(), you can do:
 * Foo.prototype.bar = goog.abstractMethod
 *
 * Now if a subclass of Foo fails to override bar(), an error will be thrown
 * when bar() is invoked.
 *
 * @type {!Function}
 * @throws {Error} when invoked to indicate the method should be overridden.
 */
goog.abstractMethod = function() {
	throw new Error('unimplemented abstract method');
};

/**
 * Adds a {@code getInstance} static method that always returns the same
 * instance object.
 * @param {!Function} ctor The constructor for the class to add the static
 *     method to.
 */
goog.addSingletonGetter = function(ctor) {
	// instance_ is immediately set to prevent issues with sealed constructors
	// such as are encountered when a constructor is returned as the export object
	// of a goog.module in unoptimized code.
	ctor.instance_ = undefined;
	ctor.getInstance = function() {
		if(ctor.instance_) {
			return ctor.instance_;
		}
		if(goog.DEBUG) {
			// NOTE: JSCompiler can't optimize away Array#push.
			goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
		}
		return ctor.instance_ = new ctor;
	};
};

/**
 * All singleton classes that have been instantiated, for testing. Don't read
 * it directly, use the {@code goog.testing.singleton} module. The compiler
 * removes this variable if unused.
 * @type {!Array<!Function>}
 * @private
 */
goog.instantiatedSingletons_ = [];

/**
 * @define {boolean} Whether to load goog.modules using {@code eval} when using
 * the debug loader.  This provides a better debugging experience as the
 * source is unmodified and can be edited using Chrome Workspaces or similar.
 * However in some environments the use of {@code eval} is banned
 * so we provide an alternative.
 */
goog.define('goog.LOAD_MODULE_USING_EVAL', true);

/**
 * @define {boolean} Whether the exports of goog.modules should be sealed when
 * possible.
 */
goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);

/**
 * The registry of initialized modules:
 * the module identifier to module exports map.
 * @private @const {!Object<string, ?>}
 */
goog.loadedModules_ = {};

/**
 * True if goog.dependencies_ is available.
 * @const {boolean}
 */
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;

/**
 * @define {string} How to decide whether to transpile.  Valid values
 * are 'always', 'never', and 'detect'.  The default ('detect') is to
 * use feature detection to determine which language levels need
 * transpilation.
 */
// NOTE(user): we could expand this to accept a language level to bypass
// detection: e.g. goog.TRANSPILE == 'es5' would transpile ES6 files but
// would leave ES3 and ES5 files alone.
goog.define('goog.TRANSPILE', 'detect');

/**
 * @define {string} Path to the transpiler.  Executing the script at this
 * path (relative to base.js) should define a function $jscomp.transpile.
 */
goog.define('goog.TRANSPILER', 'transpile.js');

/**
 * @define {string} Debug loader file to load. This file should define an
 * implementation of a `goog.DebugLoader` and register it via
 * `goog.registerDebugLoader`.
 */
goog.define('goog.DEBUG_LOADER', '');

/**
 * @package {?boolean}
 * Visible for testing.
 */
goog.hasBadLetScoping = null;

/**
 * @return {boolean}
 * @package Visible for testing.
 */
goog.useSafari10Workaround = function() {
	if(goog.hasBadLetScoping == null) {
		var hasBadLetScoping;
		try {
			hasBadLetScoping = !eval(
				'"use strict";' +
				'let x = 1; function f() { return typeof x; };' +
				'f() == "number";');
		} catch(e) {
			// Assume that ES6 syntax isn't supported.
			hasBadLetScoping = false;
		}
		goog.hasBadLetScoping = hasBadLetScoping;
	}
	return goog.hasBadLetScoping;
};

/**
 * @param {string} moduleDef
 * @return {string}
 * @package Visible for testing.
 */
goog.workaroundSafari10EvalBug = function(moduleDef) {
	return '(function(){' + moduleDef +
		'\n' + // Terminate any trailing single line comment.
		';' + // Terminate any trailing expression.
		'})();\n';
};

/**
 * @param {function(?):?|string} moduleDef The module definition.
 */
goog.loadModule = function(moduleDef) {
	// NOTE: we allow function definitions to be either in the from
	// of a string to eval (which keeps the original source intact) or
	// in a eval forbidden environment (CSP) we allow a function definition
	// which in its body must call {@code goog.module}, and return the exports
	// of the module.
	var previousState = goog.moduleLoaderState_;
	try {
		goog.moduleLoaderState_ = {
			moduleName: undefined,
			declareLegacyNamespace: false
		};
		var exports;
		if(goog.isFunction(moduleDef)) {
			exports = moduleDef.call(undefined, {});
		} else if(goog.isString(moduleDef)) {
			if(goog.useSafari10Workaround()) {
				moduleDef = goog.workaroundSafari10EvalBug(moduleDef);
			}

			exports = goog.loadModuleFromSource_.call(undefined, moduleDef);
		} else {
			throw new Error('Invalid module definition');
		}

		var moduleName = goog.moduleLoaderState_.moduleName;
		if(!goog.isString(moduleName) || !moduleName) {
			throw new Error('Invalid module name \"' + moduleName + '\"');
		}

		// Don't seal legacy namespaces as they may be uses as a parent of
		// another namespace
		if(goog.moduleLoaderState_.declareLegacyNamespace) {
			goog.constructNamespace_(moduleName, exports);
		} else if(
			goog.SEAL_MODULE_EXPORTS && Object.seal && typeof exports == 'object' &&
			exports != null) {
			Object.seal(exports);
		}

		goog.loadedModules_[moduleName] = exports;
	} finally {
		goog.moduleLoaderState_ = previousState;
	}
};

/**
 * @private @const
 */
goog.loadModuleFromSource_ = /** @type {function(string):?} */ (function() {
	// NOTE: we avoid declaring parameters or local variables here to avoid
	// masking globals or leaking values into the module definition.
	'use strict';
	var exports = {};
	eval(arguments[0]);
	return exports;
});

/**
 * Normalize a file path by removing redundant ".." and extraneous "." file
 * path components.
 * @param {string} path
 * @return {string}
 * @private
 */
goog.normalizePath_ = function(path) {
	var components = path.split('/');
	var i = 0;
	while(i < components.length) {
		if(components[i] == '.') {
			components.splice(i, 1);
		} else if(
			i && components[i] == '..' && components[i - 1] &&
			components[i - 1] != '..') {
			components.splice(--i, 2);
		} else {
			i++;
		}
	}
	return components.join('/');
};

/**
 * Provides a hook for loading a file when using Closure's goog.require() API
 * with goog.modules.  In particular this hook is provided to support Node.js.
 *
 * @type {(function(string):string)|undefined}
 */
goog.global.CLOSURE_LOAD_FILE_SYNC;

/**
 * Loads file by synchronous XHR. Should not be used in production environments.
 * @param {string} src Source URL.
 * @return {?string} File contents, or null if load failed.
 * @private
 */
goog.loadFileSync_ = function(src) {
	if(goog.global.CLOSURE_LOAD_FILE_SYNC) {
		return goog.global.CLOSURE_LOAD_FILE_SYNC(src);
	} else {
		try {
			/** @type {XMLHttpRequest} */
			var xhr = new goog.global['XMLHttpRequest']();
			xhr.open('get', src, false);
			xhr.send();
			// NOTE: Successful http: requests have a status of 200, but successful
			// file: requests may have a status of zero.  Any other status, or a
			// thrown exception (particularly in case of file: requests) indicates
			// some sort of error, which we treat as a missing or unavailable file.
			return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;
		} catch(err) {
			// No need to rethrow or log, since errors should show up on their own.
			return null;
		}
	}
};

/**
 * Lazily retrieves the transpiler and applies it to the source.
 * @param {string} code JS code.
 * @param {string} path Path to the code.
 * @return {string} The transpiled code.
 * @private
 */
goog.transpile_ = function(code, path) {
	var jscomp = goog.global['$jscomp'];
	if(!jscomp) {
		goog.global['$jscomp'] = jscomp = {};
	}
	var transpile = jscomp.transpile;
	if(!transpile) {
		var transpilerPath = goog.basePath + goog.TRANSPILER;
		var transpilerCode = goog.loadFileSync_(transpilerPath);
		if(transpilerCode) {
			// This must be executed synchronously, since by the time we know we
			// need it, we're about to load and write the ES6 code synchronously,
			// so a normal script-tag load will be too slow. Wrapped in a function
			// so that code is eval'd in the global scope.
			(function() {
				eval(transpilerCode + '\n//# sourceURL=' + transpilerPath);
			}).call(goog.global);
			// Even though the transpiler is optional, if $gwtExport is found, it's
			// a sign the transpiler was loaded and the $jscomp.transpile *should*
			// be there.
			if(goog.global['$gwtExport'] && goog.global['$gwtExport']['$jscomp'] &&
				!goog.global['$gwtExport']['$jscomp']['transpile']) {
				throw new Error(
					'The transpiler did not properly export the "transpile" ' +
					'method. $gwtExport: ' + JSON.stringify(goog.global['$gwtExport']));
			}
			// transpile.js only exports a single $jscomp function, transpile. We
			// grab just that and add it to the existing definition of $jscomp which
			// contains the polyfills.
			goog.global['$jscomp'].transpile =
				goog.global['$gwtExport']['$jscomp']['transpile'];
			jscomp = goog.global['$jscomp'];
			transpile = jscomp.transpile;
		}
	}
	if(!transpile) {
		// The transpiler is an optional component.  If it's not available then
		// replace it with a pass-through function that simply logs.
		var suffix = ' requires transpilation but no transpiler was found.';
		transpile = jscomp.transpile = function(code, path) {
			// TODO(user): figure out some way to get this error to show up
			// in test results, noting that the failure may occur in many
			// different ways, including in loadModule() before the test
			// runner even comes up.
			goog.logToConsole_(path + suffix);
			return code;
		};
	}
	// Note: any transpilation errors/warnings will be logged to the console.
	return transpile(code, path);
};

//==============================================================================
// Language Enhancements
//==============================================================================

/**
 * This is a "fixed" version of the typeof operator.  It differs from the typeof
 * operator in such a way that null returns 'null' and arrays return 'array'.
 * @param {?} value The value to get the type of.
 * @return {string} The name of the type.
 */
goog.typeOf = function(value) {
	var s = typeof value;
	if(s == 'object') {
		if(value) {
			// Check these first, so we can avoid calling Object.prototype.toString if
			// possible.
			//
			// IE improperly marshals typeof across execution contexts, but a
			// cross-context object will still return false for "instanceof Object".
			if(value instanceof Array) {
				return 'array';
			} else if(value instanceof Object) {
				return s;
			}

			// HACK: In order to use an Object prototype method on the arbitrary
			//   value, the compiler requires the value be cast to type Object,
			//   even though the ECMA spec explicitly allows it.
			var className = Object.prototype.toString.call(
				/** @type {!Object} */
				(value));
			// In Firefox 3.6, attempting to access iframe window objects' length
			// property throws an NS_ERROR_FAILURE, so we need to special-case it
			// here.
			if(className == '[object Window]') {
				return 'object';
			}

			// We cannot always use constructor == Array or instanceof Array because
			// different frames have different Array objects. In IE6, if the iframe
			// where the array was created is destroyed, the array loses its
			// prototype. Then dereferencing val.splice here throws an exception, so
			// we can't use goog.isFunction. Calling typeof directly returns 'unknown'
			// so that will work. In this case, this function will return false and
			// most array functions will still work because the array is still
			// array-like (supports length and []) even though it has lost its
			// prototype.
			// Mark Miller noticed that Object.prototype.toString
			// allows access to the unforgeable [[Class]] property.
			//  15.2.4.2 Object.prototype.toString ( )
			//  When the toString method is called, the following steps are taken:
			//      1. Get the [[Class]] property of this object.
			//      2. Compute a string value by concatenating the three strings
			//         "[object ", Result(1), and "]".
			//      3. Return Result(2).
			// and this behavior survives the destruction of the execution context.
			if((className == '[object Array]' ||
					// In IE all non value types are wrapped as objects across window
					// boundaries (not iframe though) so we have to do object detection
					// for this edge case.
					typeof value.length == 'number' &&
					typeof value.splice != 'undefined' &&
					typeof value.propertyIsEnumerable != 'undefined' &&
					!value.propertyIsEnumerable('splice')

				)) {
				return 'array';
			}
			// HACK: There is still an array case that fails.
			//     function ArrayImpostor() {}
			//     ArrayImpostor.prototype = [];
			//     var impostor = new ArrayImpostor;
			// this can be fixed by getting rid of the fast path
			// (value instanceof Array) and solely relying on
			// (value && Object.prototype.toString.vall(value) === '[object Array]')
			// but that would require many more function calls and is not warranted
			// unless closure code is receiving objects from untrusted sources.

			// IE in cross-window calls does not correctly marshal the function type
			// (it appears just as an object) so we cannot use just typeof val ==
			// 'function'. However, if the object has a call property, it is a
			// function.
			if((className == '[object Function]' ||
					typeof value.call != 'undefined' &&
					typeof value.propertyIsEnumerable != 'undefined' &&
					!value.propertyIsEnumerable('call'))) {
				return 'function';
			}

		} else {
			return 'null';
		}

	} else if(s == 'function' && typeof value.call == 'undefined') {
		// In Safari typeof nodeList returns 'function', and on Firefox typeof
		// behaves similarly for HTML{Applet,Embed,Object}, Elements and RegExps. We
		// would like to return object for those and we can detect an invalid
		// function by making sure that the function object has a call method.
		return 'object';
	}
	return s;
};

/**
 * Returns true if the specified value is null.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is null.
 */
goog.isNull = function(val) {
	return val === null;
};

/**
 * Returns true if the specified value is defined and not null.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is defined and not null.
 */
goog.isDefAndNotNull = function(val) {
	// Note that undefined == null.
	return val != null;
};

/**
 * Returns true if the specified value is an array.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an array.
 */
goog.isArray = function(val) {
	return goog.typeOf(val) == 'array';
};

/**
 * Returns true if the object looks like an array. To qualify as array like
 * the value needs to be either a NodeList or an object with a Number length
 * property. As a special case, a function value is not array like, because its
 * length property is fixed to correspond to the number of expected arguments.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an array.
 */
goog.isArrayLike = function(val) {
	var type = goog.typeOf(val);
	// We do not use goog.isObject here in order to exclude function values.
	return type == 'array' || type == 'object' && typeof val.length == 'number';
};

/**
 * Returns true if the object looks like a Date. To qualify as Date-like the
 * value needs to be an object and have a getFullYear() function.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a like a Date.
 */
goog.isDateLike = function(val) {
	return goog.isObject(val) && typeof val.getFullYear == 'function';
};

/**
 * Returns true if the specified value is a function.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a function.
 */
goog.isFunction = function(val) {
	return goog.typeOf(val) == 'function';
};

/**
 * Returns true if the specified value is an object.  This includes arrays and
 * functions.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an object.
 */
goog.isObject = function(val) {
	var type = typeof val;
	return type == 'object' && val != null || type == 'function';
	// return Object(val) === val also works, but is slower, especially if val is
	// not an object.
};

/**
 * Gets a unique ID for an object. This mutates the object so that further calls
 * with the same object as a parameter returns the same value. The unique ID is
 * guaranteed to be unique across the current session amongst objects that are
 * passed into {@code getUid}. There is no guarantee that the ID is unique or
 * consistent across sessions. It is unsafe to generate unique ID for function
 * prototypes.
 *
 * @param {Object} obj The object to get the unique ID for.
 * @return {number} The unique ID for the object.
 */
goog.getUid = function(obj) {
	// TODO(arv): Make the type stricter, do not accept null.

	// In Opera window.hasOwnProperty exists but always returns false so we avoid
	// using it. As a consequence the unique ID generated for BaseClass.prototype
	// and SubClass.prototype will be the same.
	return obj[goog.UID_PROPERTY_] ||
		(obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};

/**
 * Whether the given object is already assigned a unique ID.
 *
 * This does not modify the object.
 *
 * @param {!Object} obj The object to check.
 * @return {boolean} Whether there is an assigned unique id for the object.
 */
goog.hasUid = function(obj) {
	return !!obj[goog.UID_PROPERTY_];
};

/**
 * Removes the unique ID from an object. This is useful if the object was
 * previously mutated using {@code goog.getUid} in which case the mutation is
 * undone.
 * @param {Object} obj The object to remove the unique ID field from.
 */
goog.removeUid = function(obj) {
	// TODO(arv): Make the type stricter, do not accept null.

	// In IE, DOM nodes are not instances of Object and throw an exception if we
	// try to delete.  Instead we try to use removeAttribute.
	if(obj !== null && 'removeAttribute' in obj) {
		obj.removeAttribute(goog.UID_PROPERTY_);
	}

	try {
		delete obj[goog.UID_PROPERTY_];
	} catch(ex) {}
};

/**
 * Name for unique ID property. Initialized in a way to help avoid collisions
 * with other closure JavaScript on the same page.
 * @type {string}
 * @private
 */
goog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);

/**
 * Counter for UID.
 * @type {number}
 * @private
 */
goog.uidCounter_ = 0;

/**
 * Adds a hash code field to an object. The hash code is unique for the
 * given object.
 * @param {Object} obj The object to get the hash code for.
 * @return {number} The hash code for the object.
 * @deprecated Use goog.getUid instead.
 */
goog.getHashCode = goog.getUid;

/**
 * Removes the hash code field from an object.
 * @param {Object} obj The object to remove the field from.
 * @deprecated Use goog.removeUid instead.
 */
goog.removeHashCode = goog.removeUid;

/**
 * Clones a value. The input may be an Object, Array, or basic type. Objects and
 * arrays will be cloned recursively.
 *
 * WARNINGS:
 * <code>goog.cloneObject</code> does not detect reference loops. Objects that
 * refer to themselves will cause infinite recursion.
 *
 * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies
 * UIDs created by <code>getUid</code> into cloned results.
 *
 * @param {*} obj The value to clone.
 * @return {*} A clone of the input value.
 * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.
 */
goog.cloneObject = function(obj) {
	var type = goog.typeOf(obj);
	if(type == 'object' || type == 'array') {
		if(obj.clone) {
			return obj.clone();
		}
		var clone = type == 'array' ? [] : {};
		for(var key in obj) {
			clone[key] = goog.cloneObject(obj[key]);
		}
		return clone;
	}

	return obj;
};

/**
 * A native implementation of goog.bind.
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @private
 */
goog.bindNative_ = function(fn, selfObj, var_args) {
	return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));
};

/**
 * A pure-JS implementation of goog.bind.
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @private
 */
goog.bindJs_ = function(fn, selfObj, var_args) {
	if(!fn) {
		throw new Error();
	}

	if(arguments.length > 2) {
		var boundArgs = Array.prototype.slice.call(arguments, 2);
		return function() {
			// Prepend the bound arguments to the current arguments.
			var newArgs = Array.prototype.slice.call(arguments);
			Array.prototype.unshift.apply(newArgs, boundArgs);
			return fn.apply(selfObj, newArgs);
		};

	} else {
		return function() {
			return fn.apply(selfObj, arguments);
		};
	}
};

/**
 * Partially applies this function to a particular 'this object' and zero or
 * more arguments. The result is a new function with some arguments of the first
 * function pre-filled and the value of this 'pre-specified'.
 *
 * Remaining arguments specified at call-time are appended to the pre-specified
 * ones.
 *
 * Also see: {@link #partial}.
 *
 * Usage:
 * <pre>var barMethBound = goog.bind(myFunction, myObj, 'arg1', 'arg2');
 * barMethBound('arg3', 'arg4');</pre>
 *
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @suppress {deprecated} See above.
 */
goog.bind = function(fn, selfObj, var_args) {
	// TODO(nicksantos): narrow the type signature.
	if(Function.prototype.bind &&
		// NOTE(nicksantos): Somebody pulled base.js into the default Chrome
		// extension environment. This means that for Chrome extensions, they get
		// the implementation of Function.prototype.bind that calls goog.bind
		// instead of the native one. Even worse, we don't want to introduce a
		// circular dependency between goog.bind and Function.prototype.bind, so
		// we have to hack this to make sure it works correctly.
		Function.prototype.bind.toString().indexOf('native code') != -1) {
		goog.bind = goog.bindNative_;
	} else {
		goog.bind = goog.bindJs_;
	}
	return goog.bind.apply(null, arguments);
};

/**
 * Like goog.bind(), except that a 'this object' is not required. Useful when
 * the target function is already bound.
 *
 * Usage:
 * var g = goog.partial(f, arg1, arg2);
 * g(arg3, arg4);
 *
 * @param {Function} fn A function to partially apply.
 * @param {...*} var_args Additional arguments that are partially applied to fn.
 * @return {!Function} A partially-applied form of the function goog.partial()
 *     was invoked as a method of.
 */
goog.partial = function(fn, var_args) {
	var args = Array.prototype.slice.call(arguments, 1);
	return function() {
		// Clone the array (with slice()) and append additional arguments
		// to the existing arguments.
		var newArgs = args.slice();
		newArgs.push.apply(newArgs, arguments);
		return fn.apply(this, newArgs);
	};
};

/**
 * Copies all the members of a source object to a target object. This method
 * does not work on all browsers for all objects that contain keys such as
 * toString or hasOwnProperty. Use goog.object.extend for this purpose.
 * @param {Object} target Target.
 * @param {Object} source Source.
 */
goog.mixin = function(target, source) {
	for(var x in source) {
		target[x] = source[x];
	}

	// For IE7 or lower, the for-in-loop does not contain any properties that are
	// not enumerable on the prototype object (for example, isPrototypeOf from
	// Object.prototype) but also it will not include 'replace' on objects that
	// extend String and change 'replace' (not that it is common for anyone to
	// extend anything except Object).
};

/**
 * @return {number} An integer value representing the number of milliseconds
 *     between midnight, January 1, 1970 and the current time.
 */
goog.now = (goog.TRUSTED_SITE && Date.now) || (function() {
	// Unary plus operator converts its operand to a number which in
	// the case of
	// a date is done by calling getTime().
	return +new Date();
});

/**
 * Evals JavaScript in the global scope.  In IE this uses execScript, other
 * browsers use goog.global.eval. If goog.global.eval does not evaluate in the
 * global scope (for example, in Safari), appends a script tag instead.
 * Throws an exception if neither execScript or eval is defined.
 * @param {string} script JavaScript string.
 */
goog.globalEval = function(script) {
	if(goog.global.execScript) {
		goog.global.execScript(script, 'JavaScript');
	} else if(goog.global.eval) {
		// Test to see if eval works
		if(goog.evalWorksForGlobals_ == null) {
			try {
				goog.global.eval('var _evalTest_ = 1;');
			} catch(ignore) {}
			if(typeof goog.global['_evalTest_'] != 'undefined') {
				try {
					delete goog.global['_evalTest_'];
				} catch(ignore) {
					// Microsoft edge fails the deletion above in strict mode.
				}
				goog.evalWorksForGlobals_ = true;
			} else {
				goog.evalWorksForGlobals_ = false;
			}
		}

		if(goog.evalWorksForGlobals_) {
			goog.global.eval(script);
		} else {
			/** @type {!Document} */
			var doc = window.document;
			var scriptElt =
				/** @type {!HTMLScriptElement} */
				(doc.createElement('SCRIPT'));
			scriptElt.type = 'text/javascript';
			scriptElt.defer = false;
			// Note(user): can't use .innerHTML since "t('<test>')" will fail and
			// .text doesn't work in Safari 2.  Therefore we append a text node.
			scriptElt.appendChild(doc.createTextNode(script));
			doc.head.appendChild(scriptElt);
			doc.head.removeChild(scriptElt);
		}
	} else {
		throw new Error('goog.globalEval not available');
	}
};

/**
 * Indicates whether or not we can call 'eval' directly to eval code in the
 * global scope. Set to a Boolean by the first call to goog.globalEval (which
 * empirically tests whether eval works for globals). @see goog.globalEval
 * @type {?boolean}
 * @private
 */
goog.evalWorksForGlobals_ = null;

/**
 * Optional map of CSS class names to obfuscated names used with
 * goog.getCssName().
 * @private {!Object<string, string>|undefined}
 * @see goog.setCssNameMapping
 */
goog.cssNameMapping_;

/**
 * Optional obfuscation style for CSS class names. Should be set to either
 * 'BY_WHOLE' or 'BY_PART' if defined.
 * @type {string|undefined}
 * @private
 * @see goog.setCssNameMapping
 */
goog.cssNameMappingStyle_;

/**
 * A hook for modifying the default behavior goog.getCssName. The function
 * if present, will receive the standard output of the goog.getCssName as
 * its input.
 *
 * @type {(function(string):string)|undefined}
 */
goog.global.CLOSURE_CSS_NAME_MAP_FN;

/**
 * Handles strings that are intended to be used as CSS class names.
 *
 * This function works in tandem with @see goog.setCssNameMapping.
 *
 * Without any mapping set, the arguments are simple joined with a hyphen and
 * passed through unaltered.
 *
 * When there is a mapping, there are two possible styles in which these
 * mappings are used. In the BY_PART style, each part (i.e. in between hyphens)
 * of the passed in css name is rewritten according to the map. In the BY_WHOLE
 * style, the full css name is looked up in the map directly. If a rewrite is
 * not specified by the map, the compiler will output a warning.
 *
 * When the mapping is passed to the compiler, it will replace calls to
 * goog.getCssName with the strings from the mapping, e.g.
 *     var x = goog.getCssName('foo');
 *     var y = goog.getCssName(this.baseClass, 'active');
 *  becomes:
 *     var x = 'foo';
 *     var y = this.baseClass + '-active';
 *
 * If one argument is passed it will be processed, if two are passed only the
 * modifier will be processed, as it is assumed the first argument was generated
 * as a result of calling goog.getCssName.
 *
 * @param {string} className The class name.
 * @param {string=} opt_modifier A modifier to be appended to the class name.
 * @return {string} The class name or the concatenation of the class name and
 *     the modifier.
 */
goog.getCssName = function(className, opt_modifier) {
	// String() is used for compatibility with compiled soy where the passed
	// className can be non-string objects.
	if(String(className).charAt(0) == '.') {
		throw new Error(
			'className passed in goog.getCssName must not start with ".".' +
			' You passed: ' + className);
	}

	var getMapping = function(cssName) {
		return goog.cssNameMapping_[cssName] || cssName;
	};

	var renameByParts = function(cssName) {
		// Remap all the parts individually.
		var parts = cssName.split('-');
		var mapped = [];
		for(var i = 0; i < parts.length; i++) {
			mapped.push(getMapping(parts[i]));
		}
		return mapped.join('-');
	};

	var rename;
	if(goog.cssNameMapping_) {
		rename =
			goog.cssNameMappingStyle_ == 'BY_WHOLE' ? getMapping : renameByParts;
	} else {
		rename = function(a) {
			return a;
		};
	}

	var result =
		opt_modifier ? className + '-' + rename(opt_modifier) : rename(className);

	// The special CLOSURE_CSS_NAME_MAP_FN allows users to specify further
	// processing of the class name.
	if(goog.global.CLOSURE_CSS_NAME_MAP_FN) {
		return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);
	}

	return result;
};

/**
 * Sets the map to check when returning a value from goog.getCssName(). Example:
 * <pre>
 * goog.setCssNameMapping({
 *   "goog": "a",
 *   "disabled": "b",
 * });
 *
 * var x = goog.getCssName('goog');
 * // The following evaluates to: "a a-b".
 * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
 * </pre>
 * When declared as a map of string literals to string literals, the JSCompiler
 * will replace all calls to goog.getCssName() using the supplied map if the
 * --process_closure_primitives flag is set.
 *
 * @param {!Object} mapping A map of strings to strings where keys are possible
 *     arguments to goog.getCssName() and values are the corresponding values
 *     that should be returned.
 * @param {string=} opt_style The style of css name mapping. There are two valid
 *     options: 'BY_PART', and 'BY_WHOLE'.
 * @see goog.getCssName for a description.
 */
goog.setCssNameMapping = function(mapping, opt_style) {
	goog.cssNameMapping_ = mapping;
	goog.cssNameMappingStyle_ = opt_style;
};

/**
 * To use CSS renaming in compiled mode, one of the input files should have a
 * call to goog.setCssNameMapping() with an object literal that the JSCompiler
 * can extract and use to replace all calls to goog.getCssName(). In uncompiled
 * mode, JavaScript code should be loaded before this base.js file that declares
 * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is
 * to ensure that the mapping is loaded before any calls to goog.getCssName()
 * are made in uncompiled mode.
 *
 * A hook for overriding the CSS name mapping.
 * @type {!Object<string, string>|undefined}
 */
goog.global.CLOSURE_CSS_NAME_MAPPING;

if(!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
	// This does not call goog.setCssNameMapping() because the JSCompiler
	// requires that goog.setCssNameMapping() be called with an object literal.
	goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
}

/**
 * Gets a localized message.
 *
 * This function is a compiler primitive. If you give the compiler a localized
 * message bundle, it will replace the string at compile-time with a localized
 * version, and expand goog.getMsg call to a concatenated string.
 *
 * Messages must be initialized in the form:
 * <code>
 * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
 * </code>
 *
 * This function produces a string which should be treated as plain text. Use
 * {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to
 * produce SafeHtml.
 *
 * @param {string} str Translatable string, places holders in the form {$foo}.
 * @param {Object<string, string>=} opt_values Maps place holder name to value.
 * @return {string} message with placeholders filled.
 */
goog.getMsg = function(str, opt_values) {
	if(opt_values) {
		str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
			return(opt_values != null && key in opt_values) ? opt_values[key] :
				match;
		});
	}
	return str;
};

/**
 * Gets a localized message. If the message does not have a translation, gives a
 * fallback message.
 *
 * This is useful when introducing a new message that has not yet been
 * translated into all languages.
 *
 * This function is a compiler primitive. Must be used in the form:
 * <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>
 * where MSG_A and MSG_B were initialized with goog.getMsg.
 *
 * @param {string} a The preferred message.
 * @param {string} b The fallback message.
 * @return {string} The best translated message.
 */
goog.getMsgWithFallback = function(a, b) {
	return a;
};

/**
 * Exposes an unobfuscated global namespace path for the given object.
 * Note that fields of the exported object *will* be obfuscated, unless they are
 * exported in turn via this function or goog.exportProperty.
 *
 * Also handy for making public items that are defined in anonymous closures.
 *
 * ex. goog.exportSymbol('public.path.Foo', Foo);
 *
 * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
 *     public.path.Foo.staticFunction();
 *
 * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
 *                       Foo.prototype.myMethod);
 *     new public.path.Foo().myMethod();
 *
 * @param {string} publicPath Unobfuscated name to export.
 * @param {*} object Object the name should point to.
 * @param {Object=} opt_objectToExportTo The object to add the path to; default
 *     is goog.global.
 */
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
	goog.exportPath_(publicPath, object, opt_objectToExportTo);
};

/**
 * Exports a property unobfuscated into the object's namespace.
 * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
 * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
 * @param {Object} object Object whose static property is being exported.
 * @param {string} publicName Unobfuscated name to export.
 * @param {*} symbol Object the name should point to.
 */
goog.exportProperty = function(object, publicName, symbol) {
	object[publicName] = symbol;
};

/**
 * Inherit the prototype methods from one constructor into another.
 *
 * Usage:
 * <pre>
 * function ParentClass(a, b) { }
 * ParentClass.prototype.foo = function(a) { };
 *
 * function ChildClass(a, b, c) {
 *   ChildClass.base(this, 'constructor', a, b);
 * }
 * goog.inherits(ChildClass, ParentClass);
 *
 * var child = new ChildClass('a', 'b', 'see');
 * child.foo(); // This works.
 * </pre>
 *
 * @param {!Function} childCtor Child class.
 * @param {!Function} parentCtor Parent class.
 */
goog.inherits = function(childCtor, parentCtor) {
	/** @constructor */
	function tempCtor() {}
	tempCtor.prototype = parentCtor.prototype;
	childCtor.superClass_ = parentCtor.prototype;
	childCtor.prototype = new tempCtor();
	/** @override */
	childCtor.prototype.constructor = childCtor;

	/**
	 * Calls superclass constructor/method.
	 *
	 * This function is only available if you use goog.inherits to
	 * express inheritance relationships between classes.
	 *
	 * NOTE: This is a replacement for goog.base and for superClass_
	 * property defined in childCtor.
	 *
	 * @param {!Object} me Should always be "this".
	 * @param {string} methodName The method name to call. Calling
	 *     superclass constructor can be done with the special string
	 *     'constructor'.
	 * @param {...*} var_args The arguments to pass to superclass
	 *     method/constructor.
	 * @return {*} The return value of the superclass method/constructor.
	 */
	childCtor.base = function(me, methodName, var_args) {
		// Copying using loop to avoid deop due to passing arguments object to
		// function. This is faster in many JS engines as of late 2014.
		var args = new Array(arguments.length - 2);
		for(var i = 2; i < arguments.length; i++) {
			args[i - 2] = arguments[i];
		}
		return parentCtor.prototype[methodName].apply(me, args);
	};
};

/**
 * Call up to the superclass.
 *
 * If this is called from a constructor, then this calls the superclass
 * constructor with arguments 1-N.
 *
 * If this is called from a prototype method, then you must pass the name of the
 * method as the second argument to this function. If you do not, you will get a
 * runtime error. This calls the superclass' method with arguments 2-N.
 *
 * This function only works if you use goog.inherits to express inheritance
 * relationships between your classes.
 *
 * This function is a compiler primitive. At compile-time, the compiler will do
 * macro expansion to remove a lot of the extra overhead that this function
 * introduces. The compiler will also enforce a lot of the assumptions that this
 * function makes, and treat it as a compiler error if you break them.
 *
 * @param {!Object} me Should always be "this".
 * @param {*=} opt_methodName The method name if calling a super method.
 * @param {...*} var_args The rest of the arguments.
 * @return {*} The return value of the superclass method.
 * @suppress {es5Strict} This method can not be used in strict mode, but
 *     all Closure Library consumers must depend on this file.
 * @deprecated goog.base is not strict mode compatible.  Prefer the static
 *     "base" method added to the constructor by goog.inherits
 *     or ES6 classes and the "super" keyword.
 */
goog.base = function(me, opt_methodName, var_args) {
	var caller = arguments.callee.caller;

	if(goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller)) {
		throw new Error(
			'arguments.caller not defined.  goog.base() cannot be used ' +
			'with strict mode code. See ' +
			'http://www.ecma-international.org/ecma-262/5.1/#sec-C');
	}

	if(caller.superClass_) {
		// Copying using loop to avoid deop due to passing arguments object to
		// function. This is faster in many JS engines as of late 2014.
		var ctorArgs = new Array(arguments.length - 1);
		for(var i = 1; i < arguments.length; i++) {
			ctorArgs[i - 1] = arguments[i];
		}
		// This is a constructor. Call the superclass constructor.
		return caller.superClass_.constructor.apply(me, ctorArgs);
	}

	// Copying using loop to avoid deop due to passing arguments object to
	// function. This is faster in many JS engines as of late 2014.
	var args = new Array(arguments.length - 2);
	for(var i = 2; i < arguments.length; i++) {
		args[i - 2] = arguments[i];
	}
	var foundCaller = false;
	for(var ctor = me.constructor; ctor; ctor = ctor.superClass_ && ctor.superClass_.constructor) {
		if(ctor.prototype[opt_methodName] === caller) {
			foundCaller = true;
		} else if(foundCaller) {
			return ctor.prototype[opt_methodName].apply(me, args);
		}
	}

	// If we did not find the caller in the prototype chain, then one of two
	// things happened:
	// 1) The caller is an instance method.
	// 2) This method was not called by the right caller.
	if(me[opt_methodName] === caller) {
		return me.constructor.prototype[opt_methodName].apply(me, args);
	} else {
		throw new Error(
			'goog.base called from a method of one name ' +
			'to a method of a different name');
	}
};

/**
 * Allow for aliasing within scope functions.  This function exists for
 * uncompiled code - in compiled code the calls will be inlined and the aliases
 * applied.  In uncompiled code the function is simply run since the aliases as
 * written are valid JavaScript.
 *
 *
 * @param {function()} fn Function to call.  This function can contain aliases
 *     to namespaces (e.g. "var dom = goog.dom") or classes
 *     (e.g. "var Timer = goog.Timer").
 */
goog.scope = function(fn) {
	if(goog.isInModuleLoader_()) {
		throw new Error('goog.scope is not supported within a goog.module.');
	}
	fn.call(goog.global);
};

/*
 * To support uncompiled, strict mode bundles that use eval to divide source
 * like so:
 *    eval('someSource;//# sourceUrl sourcefile.js');
 * We need to export the globally defined symbols "goog" and "COMPILED".
 * Exporting "goog" breaks the compiler optimizations, so we required that
 * be defined externally.
 * NOTE: We don't use goog.exportSymbol here because we don't want to trigger
 * extern generation when that compiler option is enabled.
 */
if(!COMPILED) {
	goog.global['COMPILED'] = COMPILED;
}

//==============================================================================
// goog.defineClass implementation
//==============================================================================

/**
 * Creates a restricted form of a Closure "class":
 *   - from the compiler's perspective, the instance returned from the
 *     constructor is sealed (no new properties may be added).  This enables
 *     better checks.
 *   - the compiler will rewrite this definition to a form that is optimal
 *     for type checking and optimization (initially this will be a more
 *     traditional form).
 *
 * @param {Function} superClass The superclass, Object or null.
 * @param {goog.defineClass.ClassDescriptor} def
 *     An object literal describing
 *     the class.  It may have the following properties:
 *     "constructor": the constructor function
 *     "statics": an object literal containing methods to add to the constructor
 *        as "static" methods or a function that will receive the constructor
 *        function as its only parameter to which static properties can
 *        be added.
 *     all other properties are added to the prototype.
 * @return {!Function} The class constructor.
 */
goog.defineClass = function(superClass, def) {
	// TODO(johnlenz): consider making the superClass an optional parameter.
	var constructor = def.constructor;
	var statics = def.statics;
	// Wrap the constructor prior to setting up the prototype and static methods.
	if(!constructor || constructor == Object.prototype.constructor) {
		constructor = function() {
			throw new Error(
				'cannot instantiate an interface (no constructor defined).');
		};
	}

	var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
	if(superClass) {
		goog.inherits(cls, superClass);
	}

	// Remove all the properties that should not be copied to the prototype.
	delete def.constructor;
	delete def.statics;

	goog.defineClass.applyProperties_(cls.prototype, def);
	if(statics != null) {
		if(statics instanceof Function) {
			statics(cls);
		} else {
			goog.defineClass.applyProperties_(cls, statics);
		}
	}

	return cls;
};

/**
 * @typedef {{
 *   constructor: (!Function|undefined),
 *   statics: (Object|undefined|function(Function):void)
 * }}
 */
goog.defineClass.ClassDescriptor;

/**
 * @define {boolean} Whether the instances returned by goog.defineClass should
 *     be sealed when possible.
 *
 * When sealing is disabled the constructor function will not be wrapped by
 * goog.defineClass, making it incompatible with ES6 class methods.
 */
goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);

/**
 * If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is
 * defined, this function will wrap the constructor in a function that seals the
 * results of the provided constructor function.
 *
 * @param {!Function} ctr The constructor whose results maybe be sealed.
 * @param {Function} superClass The superclass constructor.
 * @return {!Function} The replacement constructor.
 * @private
 */
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
	if(!goog.defineClass.SEAL_CLASS_INSTANCES) {
		// Do now wrap the constructor when sealing is disabled. Angular code
		// depends on this for injection to work properly.
		return ctr;
	}

	// Compute whether the constructor is sealable at definition time, rather
	// than when the instance is being constructed.
	var superclassSealable = !goog.defineClass.isUnsealable_(superClass);

	/**
	 * @this {Object}
	 * @return {?}
	 */
	var wrappedCtr = function() {
		// Don't seal an instance of a subclass when it calls the constructor of
		// its super class as there is most likely still setup to do.
		var instance = ctr.apply(this, arguments) || this;
		instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];

		if(this.constructor === wrappedCtr && superclassSealable &&
			Object.seal instanceof Function) {
			Object.seal(instance);
		}
		return instance;
	};

	return wrappedCtr;
};

/**
 * @param {Function} ctr The constructor to test.
 * @return {boolean} Whether the constructor has been tagged as unsealable
 *     using goog.tagUnsealableClass.
 * @private
 */
goog.defineClass.isUnsealable_ = function(ctr) {
	return ctr && ctr.prototype &&
		ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};

// TODO(johnlenz): share these values with the goog.object
/**
 * The names of the fields that are defined on Object.prototype.
 * @type {!Array<string>}
 * @private
 * @const
 */
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
	'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
	'toLocaleString', 'toString', 'valueOf'
];

// TODO(johnlenz): share this function with the goog.object
/**
 * @param {!Object} target The object to add properties to.
 * @param {!Object} source The object to copy properties from.
 * @private
 */
goog.defineClass.applyProperties_ = function(target, source) {
	// TODO(johnlenz): update this to support ES5 getters/setters

	var key;
	for(key in source) {
		if(Object.prototype.hasOwnProperty.call(source, key)) {
			target[key] = source[key];
		}
	}

	// For IE the for-in-loop does not contain any properties that are not
	// enumerable on the prototype object (for example isPrototypeOf from
	// Object.prototype) and it will also not include 'replace' on objects that
	// extend String and change 'replace' (not that it is common for anyone to
	// extend anything except Object).
	for(var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
		key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
		if(Object.prototype.hasOwnProperty.call(source, key)) {
			target[key] = source[key];
		}
	}
};

/**
 * Sealing classes breaks the older idiom of assigning properties on the
 * prototype rather than in the constructor. As such, goog.defineClass
 * must not seal subclasses of these old-style classes until they are fixed.
 * Until then, this marks a class as "broken", instructing defineClass
 * not to seal subclasses.
 * @param {!Function} ctr The legacy constructor to tag as unsealable.
 */
goog.tagUnsealableClass = function(ctr) {
	if(!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
		ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
	}
};

/**
 * Name for unsealable tag property.
 * @const @private {string}
 */
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';

if(goog.DEPENDENCIES_ENABLED) {
	/**
	 * Tries to detect whether is in the context of an HTML document.
	 * @return {boolean} True if it looks like HTML document.
	 * @private
	 */
	goog.inHtmlDocument_ = function() {
		/** @type {!Document} */
		var doc = window.document;
		return doc != null && 'write' in doc; // XULDocument misses write.
	};

	/**
	 * Tries to detect the base path of base.js script that bootstraps Closure.
	 * @private
	 */
	goog.findBasePath_ = function() {
		if(goog.isDef(goog.global.CLOSURE_BASE_PATH) &&
			// Anti DOM-clobbering runtime check (b/37736576).
			goog.isString(goog.global.CLOSURE_BASE_PATH)) {
			goog.basePath = goog.global.CLOSURE_BASE_PATH;
			return;
		} else if(!goog.inHtmlDocument_()) {
			return;
		}
		/** @type {!Document} */
		var doc = window.document;
		// If we have a currentScript available, use it exclusively.
		var currentScript = doc.currentScript;
		if(currentScript) {
			var scripts = [currentScript];
		} else {
			var scripts = doc.getElementsByTagName('SCRIPT');
		}
		// Search backwards since the current script is in almost all cases the one
		// that has base.js.
		for(var i = scripts.length - 1; i >= 0; --i) {
			var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
			var src = script.src;
			var qmark = src.lastIndexOf('?');
			var l = qmark == -1 ? src.length : qmark;
			if(src.substr(l - 7, 7) == 'base.js') {
				goog.basePath = src.substr(0, l - 7);
				return;
			}
		}
	};

	goog.findBasePath_();

	/** @struct @constructor @final */
	goog.Transpiler = function() {
		/** @private {?Object<string, boolean>} */
		this.requiresTranspilation_ = null;
	};

	/**
	 * Returns a newly created map from language mode string to a boolean
	 * indicating whether transpilation should be done for that mode.
	 *
	 * Guaranteed invariant:
	 * For any two modes, l1 and l2 where l2 is a newer mode than l1,
	 * `map[l1] == true` implies that `map[l2] == true`.
	 *
	 * Note this method is extracted and used elsewhere, so it cannot rely on
	 * anything external (it should easily be able to be transformed into a
	 * standalone, top level function).
	 *
	 * @private
	 * @return {!Object<string, boolean>}
	 */
	goog.Transpiler.prototype.createRequiresTranspilation_ = function() {
		var /** !Object<string, boolean> */ requiresTranspilation = {
			'es3': false
		};
		var transpilationRequiredForAllLaterModes = false;

		/**
		 * Adds an entry to requiresTranspliation for the given language mode.
		 *
		 * IMPORTANT: Calls must be made in order from oldest to newest language
		 * mode.
		 * @param {string} modeName
		 * @param {function(): boolean} isSupported Returns true if the JS engine
		 *     supports the given mode.
		 */
		function addNewerLanguageTranspilationCheck(modeName, isSupported) {
			if(transpilationRequiredForAllLaterModes) {
				requiresTranspilation[modeName] = true;
			} else if(isSupported()) {
				requiresTranspilation[modeName] = false;
			} else {
				requiresTranspilation[modeName] = true;
				transpilationRequiredForAllLaterModes = true;
			}
		}

		/**
		 * Does the given code evaluate without syntax errors and return a truthy
		 * result?
		 */
		function /** boolean */ evalCheck( /** string */ code) {
			try {
				return !!eval(code);
			} catch(ignored) {
				return false;
			}
		}

		// 更改
		var userAgent = _window.navigator && _window.navigator.userAgent ?
			_window.userAgent :
			'';

		// Identify ES3-only browsers by their incorrect treatment of commas.
		addNewerLanguageTranspilationCheck('es5', function() {
			return evalCheck('[1,].length==1');
		});
		addNewerLanguageTranspilationCheck('es6', function() {
			// Edge has a non-deterministic (i.e., not reproducible) bug with ES6:
			// https://github.com/Microsoft/ChakraCore/issues/1496.
			var re = /Edge\/(\d+)(\.\d)*/i;
			var edgeUserAgent = userAgent.match(re);
			if(edgeUserAgent && Number(edgeUserAgent[1]) < 15) {
				return false;
			}
			// Test es6: [FF50 (?), Edge 14 (?), Chrome 50]
			//   (a) default params (specifically shadowing locals),
			//   (b) destructuring, (c) block-scoped functions,
			//   (d) for-of (const), (e) new.target/Reflect.construct
			var es6fullTest =
				'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}' +
				'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof ' +
				'String))throw 1;for(const a of[2,3]){if(a==2)continue;function ' +
				'f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()' +
				'==3}';

			return evalCheck('(()=>{"use strict";' + es6fullTest + '})()');
		});
		// TODO(joeltine): Remove es6-impl references for b/31340605.
		// Consider es6-impl (widely-implemented es6 features) to be supported
		// whenever es6 is supported. Technically es6-impl is a lower level of
		// support than es6, but we don't have tests specifically for it.
		addNewerLanguageTranspilationCheck('es6-impl', function() {
			return true;
		});
		// ** and **= are the only new features in 'es7'
		addNewerLanguageTranspilationCheck('es7', function() {
			return evalCheck('2 ** 2 == 4');
		});
		// async functions are the only new features in 'es8'
		addNewerLanguageTranspilationCheck('es8', function() {
			return evalCheck('async () => 1, true');
		});
		return requiresTranspilation;
	};

	/**
	 * Determines whether the given language needs to be transpiled.
	 * @param {string} lang
	 * @return {boolean}
	 */
	goog.Transpiler.prototype.needsTranspile = function(lang) {
		if(goog.TRANSPILE == 'always') {
			return true;
		} else if(goog.TRANSPILE == 'never') {
			return false;
		} else if(!this.requiresTranspilation_) {
			this.requiresTranspilation_ = this.createRequiresTranspilation_();
		}
		if(lang in this.requiresTranspilation_) {
			return this.requiresTranspilation_[lang];
		} else {
			throw new Error('Unknown language mode: ' + lang);
		}
	};

	/**
	 * Lazily retrieves the transpiler and applies it to the source.
	 * @param {string} code JS code.
	 * @param {string} path Path to the code.
	 * @return {string} The transpiled code.
	 */
	goog.Transpiler.prototype.transpile = function(code, path) {
		// TODO(user): We should delete goog.transpile_ and just have this
		// function. But there's some compile error atm where goog.global is being
		// stripped incorrectly without this.
		return goog.transpile_(code, path);
	};

	/** @private @final {!goog.Transpiler} */
	goog.transpiler_ = new goog.Transpiler();

	/**
	 * A debug loader is responsible for downloading and executing javascript
	 * files in an unbundled, uncompiled environment.
	 *
	 * @struct @constructor
	 */
	goog.DebugLoader = function() {
		/**
		 * This object is used to keep track of dependencies and other data that is
		 * used for loading scripts.
		 * @private
		 * @type {{
		 *   loadFlags: !Object<string, !Object<string, string>>,
		 *   nameToPath: !Object<string, string>,
		 *   requires: !Object<string, !Object<string, boolean>>,
		 *   visited: !Object<string, boolean>,
		 *   written: !Object<string, boolean>,
		 *   deferred: !Object<string, string>
		 * }}
		 */
		this.dependencies_ = {
			loadFlags: {}, // 1 to 1

			nameToPath: {}, // 1 to 1

			requires: {}, // 1 to many

			// Used when resolving dependencies to prevent us from visiting file
			// twice.
			visited: {},

			written: {}, // Used to keep track of script files we have written.

			deferred: {} // Used to track deferred module evaluations in old IEs
		};

		/**
		 * Whether IE9 or earlier is waiting on a dependency.  This ensures that
		 * deferred modules that have no non-deferred dependencies actually get
		 * loaded, since if we defer them and then never pull in a non-deferred
		 * script, then `this.loadQueuedModules_` will never be called.  Instead,
		 * if not waiting on anything we simply don't defer in the first place.
		 * @private {boolean}
		 */
		this.oldIeWaiting_ = false;

		/** @private {!Array<string>} */
		this.queuedModules_ = [];

		/** @private {number} */
		this.lastNonModuleScriptIndex_ = 0;
	};

	/**
	 * Whether the browser is IE9 or earlier, which needs special handling
	 * for deferred modules.
	 * @const @private {boolean}
	 */
	goog.DebugLoader.IS_OLD_IE_ = !!(!goog.global.atob && window.document && window.document.all);

	/**
	 * Performs any needed preprocessing of a goog.require call.
	 *
	 * @param {string} name
	 */
	goog.DebugLoader.prototype.earlyProcessLoad = function(name) {
		if(goog.DebugLoader.IS_OLD_IE_) {
			this.maybeProcessDeferredDep_(name);
		}
	};

	/**
	 * Loads the given symbol along with any dependencies.
	 *
	 * @param {string} name
	 */
	goog.DebugLoader.prototype.load = function(name) {
		var pathToLoad = this.getPathFromDeps_(name);
		if(!pathToLoad) {
			var errorMessage = 'goog.require could not find: ' + name;
			this.logToConsole(errorMessage);

			throw Error(errorMessage);
		} else {
			/** @type {!Array<string>} The scripts we need to write this time. */
			var scripts = [];
			var seenScript = {};
			var deps = this.dependencies_;
			var loader = this;

			/** @param {string} path */
			function visitNode(path) {
				if(path in deps.written) {
					return;
				}

				// We have already visited this one. We can get here if we have cyclic
				// dependencies.
				if(path in deps.visited) {
					return;
				}

				deps.visited[path] = true;

				if(path in deps.requires) {
					for(var requireName in deps.requires[path]) {
						// If the required name is defined, we assume that it was already
						// bootstrapped by other means.
						if(!loader.isProvided(requireName)) {
							if(requireName in deps.nameToPath) {
								visitNode(deps.nameToPath[requireName]);
							} else {
								throw Error('Undefined nameToPath for ' + requireName);
							}
						}
					}
				}

				if(!(path in seenScript)) {
					seenScript[path] = true;
					scripts.push(path);
				}
			}

			visitNode(pathToLoad);

			// record that we are going to load all these scripts.
			for(var i = 0; i < scripts.length; i++) {
				var path = scripts[i];
				this.dependencies_.written[path] = true;
			}

			for(var i = 0; i < scripts.length; i++) {
				var path = scripts[i];
				if(path) {
					var loadFlags = deps.loadFlags[path] || {};
					var languageLevel = loadFlags['lang'] || 'es3';
					var needsTranspile =
						this.getTranspiler().needsTranspile(languageLevel);
					if(loadFlags['module'] == 'goog' || needsTranspile) {
						this.importProcessedScript_(
							goog.basePath + path, loadFlags['module'] == 'goog',
							needsTranspile);
					} else {
						this.importScript_(goog.basePath + path);
					}
				} else {
					throw Error('Undefined script input');
				}
			}
		}
	};

	/**
	 * @param {string} relPath
	 * @param {!Array<string>} provides
	 * @param {!Array<string>} requires
	 * @param {boolean|!Object<string>=} opt_loadFlags
	 * @see goog.addDependency
	 */
	goog.DebugLoader.prototype.addDependency = function(
		relPath, provides, requires, opt_loadFlags) {
		var provide, require;
		var path = relPath.replace(/\\/g, '/');
		var deps = this.dependencies_;
		if(!opt_loadFlags || typeof opt_loadFlags === 'boolean') {
			opt_loadFlags = opt_loadFlags ? {
				'module': 'goog'
			} : {};
		}
		for(var i = 0; provide = provides[i]; i++) {
			deps.nameToPath[provide] = path;
			deps.loadFlags[path] = opt_loadFlags;
		}
		for(var j = 0; require = requires[j]; j++) {
			if(!(path in deps.requires)) {
				deps.requires[path] = {};
			}
			deps.requires[path][require] = true;
		}
	};

	/**
	 * Imports a script if, and only if, that script hasn't already been imported.
	 * (Must be called at execution time)
	 * @param {string} src Script source.
	 * @param {string=} opt_sourceText The optionally source text to evaluate
	 * @private
	 */
	goog.DebugLoader.prototype.importScript_ = function(src, opt_sourceText) {
		var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
			goog.bind(this.writeScriptTag_, this);
		if(importScript(src, opt_sourceText)) {
			this.dependencies_.written[src] = true;
		}
	};

	/**
	 * Given a URL initiate retrieval and execution of a script that needs
	 * pre-processing.
	 * @param {string} src Script source URL.
	 * @param {boolean} isModule Whether this is a goog.module.
	 * @param {boolean} needsTranspile Whether this source needs transpilation.
	 * @private
	 */
	goog.DebugLoader.prototype.importProcessedScript_ = function(
		src, isModule, needsTranspile) {
		// In an attempt to keep browsers from timing out loading scripts using
		// synchronous XHRs, put each load in its own script block.
		var bootstrap = 'goog.debugLoader_.retrieveAndExec_("' + src + '", ' +
			isModule + ', ' + needsTranspile + ');';

		this.importScript_('', bootstrap);
	};

	/**
	 * Retrieve and execute a script that needs some sort of wrapping.
	 * @param {string} src Script source URL.
	 * @param {boolean} isModule Whether to load as a module.
	 * @param {boolean} needsTranspile Whether to transpile down to ES3.
	 * @private
	 * @suppress {unusedPrivateMembers}
	 */
	goog.DebugLoader.prototype.retrieveAndExec_ = function(
		src, isModule, needsTranspile) {
		if(!COMPILED) {
			// The full but non-canonicalized URL for later use.
			var originalPath = src;
			// Canonicalize the path, removing any /./ or /../ since Chrome's
			// debugging console doesn't auto-canonicalize XHR loads as it does
			// <script> srcs.
			src = this.normalizePath(src);

			var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
				goog.bind(this.writeScriptTag_, this);

			var scriptText = this.loadFileSync(src);
			if(scriptText == null) {
				throw new Error('Load of "' + src + '" failed');
			}

			if(needsTranspile) {
				scriptText = this.getTranspiler().transpile(scriptText, src);
			}

			if(isModule) {
				scriptText = this.wrapModule_(src, scriptText);
			} else {
				scriptText += '\n//# sourceURL=' + src;
			}
			var isOldIE = goog.DebugLoader.IS_OLD_IE_;
			if(isOldIE && this.oldIeWaiting_) {
				this.dependencies_.deferred[originalPath] = scriptText;
				this.queuedModules_.push(originalPath);
			} else {
				importScript(src, scriptText);
			}
		}
	};

	/**
	 * Return an appropriate module text. Suitable to insert into
	 * a script tag (that is unescaped).
	 * @param {string} srcUrl
	 * @param {string} scriptText
	 * @return {string}
	 * @private
	 */
	goog.DebugLoader.prototype.wrapModule_ = function(srcUrl, scriptText) {
		if(!goog.LOAD_MODULE_USING_EVAL || !goog.isDef(goog.global.JSON)) {
			return '' +
				'goog.loadModule(function(exports) {' +
				'"use strict";' + scriptText +
				'\n' + // terminate any trailing single line comment.
				';return exports' +
				'});' +
				'\n//# sourceURL=' + srcUrl + '\n';
		} else {
			return '' +
				'goog.loadModule(' +
				goog.global.JSON.stringify(
					scriptText + '\n//# sourceURL=' + srcUrl + '\n') +
				');';
		}
	};

	// On IE9 and earlier, it is necessary to handle
	// deferred module loads. In later browsers, the
	// code to be evaluated is simply inserted as a script
	// block in the correct order. To eval deferred
	// code at the right time, we piggy back on goog.require to call
	// this.maybeProcessDeferredDep_.
	//
	// The goog.requires are used both to bootstrap
	// the loading process (when no deps are available) and
	// declare that they should be available.
	//
	// Here we eval the sources, if all the deps are available
	// either already eval'd or goog.require'd.  This will
	// be the case when all the dependencies have already
	// been loaded, and the dependent module is loaded.
	//
	// But this alone isn't sufficient because it is also
	// necessary to handle the case where there is no root
	// that is not deferred.  For that there we register for an event
	// and trigger this.loadQueuedModules_ handle any remaining deferred
	// evaluations.

	/**
	 * Handle any remaining deferred goog.module evals.
	 * @private
	 */
	goog.DebugLoader.prototype.loadQueuedModules_ = function() {
		var count = this.queuedModules_.length;
		if(count > 0) {
			var queue = this.queuedModules_;
			this.queuedModules_ = [];
			for(var i = 0; i < count; i++) {
				var path = queue[i];
				this.maybeProcessDeferredPath_(path);
			}
		}
		this.oldIeWaiting_ = false;
	};

	/**
	 * Eval the named module if its dependencies are
	 * available.
	 * @param {string} name The module to load.
	 * @private
	 */
	goog.DebugLoader.prototype.maybeProcessDeferredDep_ = function(name) {
		if(this.isDeferredModule_(name) && this.allDepsAreAvailable_(name)) {
			var path = this.getPathFromDeps_(name);
			this.maybeProcessDeferredPath_(goog.basePath + path);
		}
	};

	/**
	 * @param {string} name The module to check.
	 * @return {boolean} Whether the name represents a
	 *     module whose evaluation has been deferred.
	 * @private
	 */
	goog.DebugLoader.prototype.isDeferredModule_ = function(name) {
		var path = this.getPathFromDeps_(name);
		var loadFlags = path && this.dependencies_.loadFlags[path] || {};
		var languageLevel = loadFlags['lang'] || 'es3';
		if(path &&
			(loadFlags['module'] == 'goog' ||
				this.getTranspiler().needsTranspile(languageLevel))) {
			var abspath = goog.basePath + path;
			return(abspath) in this.dependencies_.deferred;
		}
		return false;
	};

	/**
	 * @param {string} name The module to check.
	 * @return {boolean} Whether the name represents a
	 *     module whose declared dependencies have all been loaded
	 *     (eval'd or a deferred module load)
	 * @private
	 */
	goog.DebugLoader.prototype.allDepsAreAvailable_ = function(name) {
		var path = this.getPathFromDeps_(name);
		if(path && (path in this.dependencies_.requires)) {
			for(var requireName in this.dependencies_.requires[path]) {
				if(!this.isProvided(requireName) &&
					!this.isDeferredModule_(requireName)) {
					return false;
				}
			}
		}
		return true;
	};

	/**
	 * @param {string} abspath
	 * @private
	 */
	goog.DebugLoader.prototype.maybeProcessDeferredPath_ = function(abspath) {
		if(abspath in this.dependencies_.deferred) {
			var src = this.dependencies_.deferred[abspath];
			delete this.dependencies_.deferred[abspath];
			goog.globalEval(src);
		}
	};

	/**
	 * Writes a new script pointing to {@code src} directly into the DOM.
	 *
	 * NOTE: This method is not CSP-compliant. @see this.appendScriptSrcNode_ for
	 * the fallback mechanism.
	 *
	 * @param {string} src The script URL.
	 * @private
	 */
	goog.DebugLoader.prototype.writeScriptSrcNode_ = function(src) {
		window.document.write(
			'<script type="text/javascript" src="' + src + '"></' +
			'script>');
	};

	/**
	 * Appends a new script node to the DOM using a CSP-compliant mechanism. This
	 * method exists as a fallback for document.write (which is not allowed in a
	 * strict CSP context, e.g., Chrome apps).
	 *
	 * NOTE: This method is not analogous to using document.write to insert a
	 * <script> tag; specifically, the user agent will execute a script added by
	 * document.write immediately after the current script block finishes
	 * executing, whereas the DOM-appended script node will not be executed until
	 * the entire document is parsed and executed. That is to say, this script is
	 * added to the end of the script execution queue.
	 *
	 * The page must not attempt to call goog.required entities until after the
	 * document has loaded, e.g., in or after the window.onload callback.
	 *
	 * @param {string} src The script URL.
	 * @private
	 */
	goog.DebugLoader.prototype.appendScriptSrcNode_ = function(src) {
		/** @type {!Document} */
		var doc = window.document;
		var scriptEl =
			/** @type {!HTMLScriptElement} */
			(doc.createElement('script'));
		scriptEl.type = 'text/javascript';
		scriptEl.src = src;
		scriptEl.defer = false;
		scriptEl.async = false;
		doc.head.appendChild(scriptEl);
	};

	/**
	 * The default implementation of the import function. Writes a script tag to
	 * import the script.
	 *
	 * @param {string} src The script url.
	 * @param {string=} opt_sourceText The optionally source text to evaluate
	 * @return {boolean} True if the script was imported, false otherwise.
	 * @private
	 */
	goog.DebugLoader.prototype.writeScriptTag_ = function(src, opt_sourceText) {
		if(this.inHtmlDocument()) {
			/** @type {!HTMLDocument} */
			var doc = window.document;

			// If the user tries to require a new symbol after document load,
			// something has gone terribly wrong. Doing a document.write would
			// wipe out the page. This does not apply to the CSP-compliant method
			// of writing script tags.
			if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
				doc.readyState == 'complete') {
				// Certain test frameworks load base.js multiple times, which tries
				// to write deps.js each time. If that happens, just fail silently.
				// These frameworks wipe the page between each load of base.js, so this
				// is OK.
				var isDeps = /\bdeps.js$/.test(src);
				if(isDeps) {
					return false;
				} else {
					throw Error('Cannot write "' + src + '" after document load');
				}
			}

			if(opt_sourceText === undefined) {
				if(!goog.DebugLoader.IS_OLD_IE_) {
					if(goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
						this.appendScriptSrcNode_(src);
					} else {
						this.writeScriptSrcNode_(src);
					}
				} else {
					this.oldIeWaiting_ = true;
					var state = ' onreadystatechange=\'goog.debugLoader_' +
						'.onScriptLoad_(this, ' + ++this.lastNonModuleScriptIndex_ +
						')\' ';
					doc.write(
						'<script type="text/javascript" src="' + src + '"' + state +
						'></' +
						'script>');
				}
			} else {
				doc.write(
					'<script type="text/javascript">' +
					this.protectScriptTag_(opt_sourceText) + '</' +
					'script>');
			}
			return true;
		} else {
			return false;
		}
	};

	/**
	 * Rewrites closing script tags in input to avoid ending an enclosing script
	 * tag.
	 *
	 * @param {string} str
	 * @return {string}
	 * @private
	 */
	goog.DebugLoader.prototype.protectScriptTag_ = function(str) {
		return str.replace(/<\/(SCRIPT)/ig, '\\x3c/$1');
	};

	/**
	 * A readystatechange handler for legacy IE
	 * @param {?} script
	 * @param {number} scriptIndex
	 * @return {boolean}
	 * @private
	 * @suppress {unusedPrivateMembers}
	 */
	goog.DebugLoader.prototype.onScriptLoad_ = function(script, scriptIndex) {
		// for now load the modules when we reach the last script,
		// later allow more inter-mingling.
		if(script.readyState == 'complete' &&
			this.lastNonModuleScriptIndex_ == scriptIndex) {
			this.loadQueuedModules_();
		}
		return true;
	};

	/**
	 * Looks at the dependency rules and tries to determine the script file that
	 * fulfills a particular rule.
	 * @param {string} rule In the form goog.namespace.Class or project.script.
	 * @return {?string} Url corresponding to the rule, or null.
	 * @private
	 */
	goog.DebugLoader.prototype.getPathFromDeps_ = function(rule) {
		if(rule in this.dependencies_.nameToPath) {
			return this.dependencies_.nameToPath[rule];
		} else {
			return null;
		}
	};

	/**
	 * @return {!goog.Transpiler}
	 * @protected @final
	 */
	goog.DebugLoader.prototype.getTranspiler = function() {
		return goog.transpiler_;
	};

	/**
	 * @param {string} namespaceOrPath
	 * @return {boolean}
	 * @protected @final
	 */
	goog.DebugLoader.prototype.isProvided = function(namespaceOrPath) {
		return goog.isProvided_(namespaceOrPath);
	};

	/**
	 * @return {boolean}
	 * @protected @final
	 */
	goog.DebugLoader.prototype.inHtmlDocument = function() {
		return goog.inHtmlDocument_();
	};

	/**
	 * @param {string} message
	 * @protected @final
	 */
	goog.DebugLoader.prototype.logToConsole = function(message) {
		goog.logToConsole_(message);
	};

	/**
	 * @param {string} srcUrl
	 * @return {?string}
	 * @protected @final
	 */
	goog.DebugLoader.prototype.loadFileSync = function(srcUrl) {
		return goog.loadFileSync_(srcUrl);
	};

	/**
	 * @param {string} path
	 * @return {string}
	 * @protected @final
	 */
	goog.DebugLoader.prototype.normalizePath = function(path) {
		return goog.normalizePath_(path);
	};

	/** @private {?goog.DebugLoader} */
	goog.debugLoader_ = null;

	/** @param {!goog.DebugLoader} loader */
	goog.registerDebugLoader = function(loader) {
		if(goog.debugLoader_) {
			throw new Error('Debug loader already registered!');
		}
		if(!(loader instanceof goog.DebugLoader)) {
			throw new Error('Not a goog.DebugLoader.');
		}
		goog.debugLoader_ = loader;
	};

	/** @private @return {!goog.DebugLoader} */
	goog.getLoader_ = function() {
		if(!goog.debugLoader_ && goog.DEBUG_LOADER) {
			// Tried to load earlier but failed.
			throw new Error('Loaded debug loader file but no loader was registered!');
		} else if(!goog.debugLoader_) {
			// No custom loader and no closure deps. Was not made earlier; make it
			// now.
			goog.debugLoader_ = new goog.DebugLoader();
		}
		return goog.debugLoader_;
	};

	(function() {
		var tempLoader;
		if(goog.DEBUG_LOADER) {
			tempLoader = new goog.DebugLoader();
			tempLoader.importScript_(goog.basePath + goog.DEBUG_LOADER);
		}

		// Allow projects to manage the deps files themselves.
		if(!goog.global.CLOSURE_NO_DEPS) {
			tempLoader = tempLoader || new goog.DebugLoader();
			if(!goog.DEBUG_LOADER) {
				// Can reuse the same debug loader in the rest of the application.
				goog.registerDebugLoader(tempLoader);
			}
			tempLoader.importScript_(goog.basePath + 'deps.js');
		}
	})();
}